class EvaluacionesController < ApplicationController
  #MODULE: Configuraciones

  before_filter :inicializar_preguntas, :only => :update
  before_filter :require_admin_user
  def reiniciar_datos #IGNORE
    @evaluacion=Evaluacion.find(params[:id])
    ids=UsuarioDato.por_evaluacion(@evaluacion).map(&:id)
    cant1=UsuarioDato.delete_all("id IN (#{ids.join(",")})") unless ids.empty?
    ids=UsuarioPregunta.por_evaluacion(@evaluacion).map(&:id)
    cant=UsuarioPregunta.delete_all("id IN (#{ids.join(",")})") unless ids.empty?
    ids=ResultadoCompetencia.por_evaluacion(@evaluacion).map(&:id)
    cant=ResultadoCompetencia.delete_all("id IN (#{ids.join(",")})") unless ids.empty?
    @evaluacion.evaluados.each do |evaluado|
      evaluado.evaluado.asignar_preguntas(@evaluacion)
      evaluado.evaluado.asignar_datos(@evaluacion)
      evaluado.usuario.asignar_datos(@evaluacion)
    end
    redirect_to @evaluacion
  end

  def resumen_participantes  #DESC: Visualizar el resumen de participantes, con sus evaluados y evaluadores
    @resumen={}
    @evaluacion_id=params[:id]
    Usuario.activos(:order=>:nombres).each do |u|
      sus_evaluadores=Evaluado.find_all_by_evaluado_id_and_evaluacion_id(u.id,params[:id]).map(&:usuario)
      sus_evaluados=Evaluado.find_all_by_usuario_id_and_evaluacion_id(u.id,params[:id])
      next if (sus_evaluadores.empty? and sus_evaluados.empty?)
      @resumen[u.id]={}
      @resumen[u.id][:usuario]=u
      @resumen[u.id][:evaluadores]=sus_evaluadores
      @resumen[u.id][:evaluados]=sus_evaluados
    end
  end

  def show_pregunta #IGNORE
    @pregunta=Pregunta.find(params[:id])
  end

  def index
  end

  def reporte  #DESC: Descargar los reportes de una evaluacion
    evaluacion=Evaluacion.find(params[:id])
    respond_to do |format|
      format.csv do
        reporte=evaluacion.reporte(params[:tipo])
        send_data reporte,:filename => "Reporte_-_#{params[:tipo]}_-_#{evaluacion.nombre_para_archivo}.csv",
          :type => 'text/csv; charset=iso-8859-1; header=present',
          :disposition => "attachment",
          :encoding => 'U'
      end
    end
  end

  def duplicar #DESC: Duplicar una evaluacion
    nueva=Evaluacion.duplicar(params[:evaluacion])
    flash[:notice] = "'<b>#{nueva.nombre}'</b> creada correctamente."
    redirect_to evaluaciones_path
  end

  def show
    @evaluacion = Evaluacion.find params[:id]
  end

  def new
    @evaluacion = Evaluacion.new
  end

  def create
    @evaluacion = Evaluacion.new(params[:evaluacion])
    respond_to do |format|
      if @evaluacion.save
        flash[:notice] = "La evaluacion se cargo correctamente"
        format.html { redirect_to(@evaluacion)}
      else
        format.html { render :action => "new" }
        format.xml  { render :xml => @evaluacion.errors, :status => :unprocessable_entity }
      end
    end
  end

  def update
    @evaluacion = Evaluacion.find params[:id]
    respond_to do |format|
      if @evaluacion.update_attributes(params[:evaluacion])
        flash[:notice] = "La evaluacion se cargo correctamente"
        format.html { redirect_to(@evaluacion)}
      else
        format.html { render :action => "new" }
        format.xml  { render :xml => @evaluacion.errors, :status => :unprocessable_entity }
      end
    end
  end

  def edit
    @evaluacion = Evaluacion.find params[:id]
    @preguntas  = @evaluacion.preguntas
  end

  def destroy
    @evaluacion = Evaluacion.find params[:id]
    if @evaluacion.destroy
      redirect_to evaluaciones_path
    end
  end

  def nueva_pregunta #IGNORE
    @pregunta = Pregunta.new
  end

  def nueva_opcion #IGNORE
    @opcion = Opcion.new
  end

  def quitar_opcion #IGNORE
    @opcion = Opcion.find params[:opcion_id]
    @opcion.destroy
    render :nothing => true
  end

    def datos #IGNORE
    #Realizar consulta
    registros, count = find_by_params(params, :class => Evaluacion)
    # Construct a hash from the ActiveRecord result
    return_data = Hash.new()
    return_data[:page] = params[:page]
    return_data[:total] = (count.to_f / params[:rows].to_i).ceil
    return_data[:records] = count

    return_data[:rows] = registros.collect{|u| {:id=>u.id,
        :cell=>[
          u.nombre,
          I18n.l(u.fecha,:format => :date ),
          u.estado,
          u.link_reporte("completo"),
          u.link_reporte("totalizado")
        ]}}

    # Convert the hash to a json object
    render :text=>return_data.to_json, :layout=>false
  end


  def auto_complete_for_competencia_titulo #IGNORE
    competencias =  Competencia.find(:all,
      :conditions => ['LOWER(titulo) LIKE ?', '%' + params[:q].downcase + '%' ],
      :order      => 'titulo ASC',
      :limit      => 8)
    items = competencias.map{|c| "<span id='#{c.id}' onclick='completeOnClick(#{params[:indice]})'>#{c.titulo}</span><p>#{c.tipo}</p>"}
    render :text => items.join("\n")
  end
  
  def auto_complete_for_cargo_nombre #IGNORE
    cargos =  Cargo.find(:all,
      :conditions => ['LOWER(nombre) LIKE ?', '%' + params[:q].downcase + '%' ],
      :order      => 'nombre ASC',
      :limit      => 8)
    items = cargos.map{|c| "<span id='#{c.id}' onclick='completeOnClick(#{params[:indice]}, \"cargo\")'>#{c.nombre}</span>"}
    render :text => items.join("\n")
  end

  protected

  def inicializar_preguntas
    params[:evaluacion][:existing_pregunta_attributes] ||= {}
  end


  def require_admin_user
    redirect_to denegado_path unless current_user.tiene_perfil?('Administrador')
  end

end

